home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / scope / 201-220 / scopedisk211 / amenu / parse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-20  |  12.1 KB  |  413 lines
  1. /*********************************************************************\
  2. **                               ________________________________    **
  3. **    A n t h o n y             |________    __    __    ________|   **
  4. **                                       |  |o_|  |o_|  |            **
  5. **            T h y s s e n            __|   __    __   |__          **
  6. **                                  __|   __|  |  |  |__   |__       **
  7. **   `` Dragon Computing ! ''    __|   __|     |  |     |__   |__    **
  8. **                              |_____|        |__|        |_____|   **
  9. **                                                                   **
  10. \*********************************************************************/
  11. /*   Parse the users configuration file to set up the extra workbench
  12. ** menus to execute various commands is various ways.
  13. **                                             (See documentation)
  14. */
  15. #undef DBUG   /* don't debug this unless nessary! */
  16. #include "AMenu.h"
  17. #include "AllocStr.h"        /* allocation/copy macro routines */
  18.  
  19.  
  20.   /* Externs */
  21. extern UBYTE    Color[], TColor[];
  22. extern UWORD    FontWidth;
  23. extern USHORT   ItemStyle;
  24. extern unsigned MenuGap, WBMenus;
  25.  
  26. extern void  Warn(char *);
  27. extern void  StartMenu(), AddTitle(char *), AddSkip();
  28. extern struct ExtMenuItem   *AddItem(char *, char);
  29. extern void  AddMenu(char *, int), AddSubMenu(char *, int);
  30. extern void  EndMenu(), EndSubMenu();
  31. extern BOOL  FinishMenu();
  32.  
  33.  
  34. enum status {        /* Parse structure levels */
  35.   STAT_ENTRY, STAT_MENU, STAT_SUB
  36. };
  37.  
  38.   /* Multi character tokens */
  39. enum {
  40.   EOF = -1, STRING,
  41.   CONSOLE, DIRECTORY, COLOR, TCOLOR, STYLE, COMP, BOX, MENUGAP,
  42.   MENU, SUBMENU, ENDMENU, ENDSUBMENU, COLUMNS, ITEM, TITLE, SKIP,
  43.   RB, RUNBACK, CLI, SCR, SCRIPT, WB,   STK, PRI, CON, DIR,   EndToken
  44. };    /* Note command the modes `RB' to `WB' must be in together */
  45.  
  46.  /* The Arp keyword parsing string - in numeral order of tokens above */
  47. char  *TokenTemplate =
  48.  "CONSOLE,DIRECTORY,COLOR,TCOLOR,STYLE,COMP,BOX,MENUGAP,MENU,SUBMENU,ENDMENU,ENDSUBMENU,COLUMNS,ITEM,TITLE,SKIP,RB,RUNBACK,CLI,SCR,SCRIPT,WB,STK,PRI,CON,DIR";
  49.  
  50.  /* checks on the type of a commands argument */
  51. #define isstring(t) ( (t)<EndToken )       /* is the token any string */
  52. #define isnumber(t) ( isstring(t) && isdigit(*String) )
  53.  
  54.  
  55. #define S_SIZE  80
  56. char    String[S_SIZE], NextChar;   /* string token, char after string */
  57. BPTR    Config;           /* File Handle */
  58.  
  59.  
  60. /*   NOTE :- The Lattice 5.04 library function `isalnum()' is
  61. ** incorrect in that the characters  :;<=>?@ are true (is an
  62. ** alphanumeric character).  The library functions `isdigit()'
  63. ** and `isalpha()' is correct, and thus used instead.
  64. **   The macro isalnum() in "ctype.h" works correctly, but
  65. ** involves the linking of the 256 byte flag buffer `_ctype[]'
  66. ** used by the macros.
  67. */
  68. #define isalnum(c)  (isalpha(c) || isdigit(c))
  69.  
  70.  
  71. /*--------------------------------------*/
  72.  
  73. static int LineNum = 0;      /* Line number in config file - 0 = No Need */
  74.  
  75.    /* return a True on any error given to the user */
  76. #define ReportError(Msg)  { UserReport(Msg); return TRUE; }
  77.  
  78. static void
  79. UserReport(Msg)
  80.   char *Msg;
  81. {
  82.   if( LineNum )
  83.     SPrintf(String, "%s : Line %ld \"%s\"", VERSION, LineNum, Msg);
  84.   else
  85.     SPrintf(String, "%s : \"%s\"", VERSION, Msg);
  86.   Printf("\n%s\n", String);  /* CLI Report */
  87.   Warn(String);              /* WB  Report */
  88. }
  89.  
  90.  
  91. static char
  92. GetC()
  93. {
  94.  char c = EOF;
  95.  Read(Config, &c, 1);
  96.  if( c == '\n' )
  97.    LineNum++;
  98.  return c;
  99. }
  100.  
  101.  
  102. static char
  103. GetToken()
  104. {
  105.   char quote;
  106.   register char tok, *p;
  107.   register int i;
  108.  
  109. retry:
  110.   while(isspace(tok=GetC()));             /* skip extra spaces */
  111.   if( tok == '#' ) {                         /* comment */
  112.     while( (tok=GetC()) != '\n' && tok != EOF ) ;
  113.     goto retry;
  114.   }
  115.   quote = (tok == '"');
  116.   if( !quote && !isalnum(tok) )           /* individual Char */
  117.     return tok;
  118.   if( quote )                             /* remove open quote */
  119.     tok=GetC();
  120.  
  121.     /* scan string token -- while !EOF, space in buffer */
  122.   for( i=0, p=String;
  123.          tok != EOF && i < (S_SIZE-1) && (quote ? tok!='"' : !isspace(tok));
  124.            *p++=tok, i++, tok=GetC()  );
  125.   *p = '\0';
  126.   NextChar = tok;   /* record the next character after String */
  127.     /* Use ARP to sort the keywords from the strings */
  128.   tok = GetKeywordIndex( String, TokenTemplate ) + 1; /* convert token */
  129.   DB( Printf( "%s ", String ); )
  130.   return tok;
  131. }
  132.  
  133.  
  134.  
  135. static BOOL
  136. ParseConfig()
  137. {
  138.   register char       t, Statement;
  139.   struct ExtMenuItem *EItem;
  140.   char                Name[80], CommandChar, *p;
  141.   BOOL                OptionLoop;
  142.   enum status         status = STAT_ENTRY;
  143.   int                 Columns;
  144.  
  145.   LineNum = 1;         /* report config line number on errors */
  146.   DB( Printf("\n"); )
  147.   while ( (Statement=GetToken()) != EOF ) {
  148.     switch( Statement ) {
  149.     case CONSOLE:
  150.       if( !isstring(GetToken()) )
  151.         ReportError("Bad CONSOLE Argument");
  152.       if( M->Console )  FreeStr(M->Console);
  153.       M->Console = AllocStr(String);
  154.       break;
  155.     case DIRECTORY:
  156.       if( !isstring(GetToken()) )
  157.         ReportError("Bad DIRECTORY Argument");
  158.       if( M->Directory )  FreeStr(M->Directory);
  159.       M->Directory = AllocStr(String);
  160.       break;
  161.  
  162.     case COLOR:
  163.       if( !isnumber(GetToken()) )
  164.         ReportError("Bad COLOR Argument 1");
  165.       Color[0] = (UWORD)Atol(String);
  166.       if( !isnumber(GetToken()) )
  167.         ReportError("Bad COLOR Argument 2");
  168.       Color[1] = (UWORD)Atol(String);
  169.       break;
  170.  
  171.     case TCOLOR:
  172.       if( !isnumber(GetToken()) )
  173.         ReportError("Bad TCOLOR Argument 1");
  174.       TColor[0] = (UWORD)Atol(String);
  175.       if( !isnumber(GetToken()) )
  176.         ReportError("Bad TCOLOR Argument 2");
  177.       TColor[1] = (UWORD)Atol(String);
  178.       break;
  179.  
  180.     case STYLE:
  181.       switch( GetToken() ) {
  182.       case COMP: ItemStyle = HIGHCOMP; break;
  183.       case BOX:  ItemStyle = HIGHBOX;  break;
  184.       default:
  185.         ReportError("Bad STYLE Argument");
  186.       }
  187.       break;
  188.  
  189.     case MENUGAP:
  190.       if( !isnumber(GetToken()) )
  191.         ReportError("Bad MENUGAP Argument");
  192.       MenuGap = (UWORD)Atol(String);
  193.       if( MenuGap<1 || MenuGap>50 )
  194.         ReportError("MENUGAP out of range");
  195.       MenuGap *= FontWidth;
  196.       break;
  197.  
  198.     case MENU:
  199.       switch( status ) {  /* fall through switch */
  200.       case STAT_SUB:
  201.         EndSubMenu();
  202.       case STAT_MENU:
  203.         EndMenu();
  204.       }
  205.       status = STAT_MENU;
  206.       Columns = 1;
  207.       if( (t=GetToken() == COLUMNS ) ) {
  208.         if( !isnumber(t=GetToken()) )
  209.           ReportError("Bad COLUMNS Argument");
  210.         Columns = Atol(String);
  211.         t=GetToken();
  212.       }
  213.       if( !isstring(t) )
  214.         ReportError("Missing Menu Name");
  215.       AddMenu( String, Columns );
  216.       break;
  217.  
  218.     case SUBMENU:
  219.       switch( status ) {
  220.       case STAT_ENTRY:
  221.         ReportError("Menu Statement expected");
  222.       case STAT_SUB:
  223.         EndSubMenu();
  224.       }
  225.       status = STAT_SUB;
  226.       Columns = 1;
  227.       if( (t=GetToken() == COLUMNS ) ) {
  228.         if( !isnumber(t=GetToken()) )
  229.           ReportError("Bad COLUMNS Argument");
  230.         Columns = Atol(String);
  231.         t=GetToken();
  232.       }
  233.       if( !isstring(t) )
  234.         ReportError("Missing SubMenu Name");
  235.       AddSubMenu( String, Columns );
  236.       break;
  237.  
  238.     case ENDMENU:
  239.       switch( status ) {
  240.       case STAT_ENTRY:
  241.         ReportError("Menu Statment expected");
  242.       case STAT_SUB:
  243.         EndSubMenu();
  244.       }
  245.       EndMenu();
  246.       status = STAT_ENTRY;
  247.       break;
  248.  
  249.     case ENDSUBMENU:
  250.       if( status != STAT_SUB ) {
  251.         ReportError("SubMenu Statment expected");
  252.       }
  253.       EndSubMenu();
  254.       status = STAT_MENU;
  255.       break;
  256.  
  257.  
  258.     case SKIP:       /* these are pretty simalar */
  259.     case TITLE:
  260.     case ITEM:
  261.       switch( status ) {
  262.       case STAT_ENTRY:
  263.         ReportError("Menu Statement expected");
  264.       }
  265.       if( Statement == SKIP ) {     /* if Skip finish up */
  266.         AddSkip();
  267.         break;
  268.       }
  269.       if( !isstring(GetToken()) )
  270.         ReportError("Missing Item/Title Name");
  271.       strcpy(Name, String);
  272.  
  273.       if( Statement == TITLE ) {    /* if Title finish up */
  274.         AddTitle(Name);
  275.         break;
  276.       }
  277.       CommandChar = '\0';
  278.       if( (t=GetToken()) == '<' ) {     /* command char */
  279.         /* the next line works with 1.3
  280.          * however, WB 2.0 has its own CTRL characters
  281.          * so simply get a token
  282.         CommandChar = GetC();
  283.          */
  284.         (void)GetC();    /* WB 2.0 "new" code */
  285.         if( GetToken() != '>' )
  286.           ReportError("Missing closing '>'");
  287.         t = GetToken();
  288.       }
  289.       if( t != '|' )
  290.         ReportError("Missing '|' separator");
  291.       DB( Printf("| "); )
  292.       EItem = AddItem(Name, CommandChar);
  293.       if( (t=GetToken()) < RB || t > WB )
  294.         ReportError("Missing Execution Mode");
  295.       EItem->Mode  = Toupper(String[0]);   /* R,C,S,W as appropiate */
  296.       EItem->Stack = DEF_STACK;            /* Default Stack Size */
  297.       EItem->Pri   = 0;                    /* Default Prioity */
  298.       for( OptionLoop=TRUE; OptionLoop; ) {
  299.         switch( t=GetToken() ) {
  300.         case STK:        /* Stack -- All modes */
  301.           if( !isnumber(t=GetToken()) )
  302.             ReportError("Bad STK Argument");
  303.           EItem->Stack = (ULONG)Atol(String);
  304.           if( EItem->Stack < 500 || EItem->Stack > 1000000 )
  305.             ReportError("Bad STACK Size given");
  306.           break;
  307.         case PRI:        /* Prioity -- All modes */
  308.           { BOOL neg;
  309.             if( neg = ( (t=GetToken()) == '-') ) t=GetToken();
  310.             if( !isnumber(t) )
  311.               ReportError("Bad PRI Argument");
  312.             EItem->Pri = (BYTE)Atol(String);
  313.             if(neg) EItem->Pri = -EItem->Pri;
  314.           }
  315.           break;
  316.         case CON:        /* Console -- CLI & SCRIPT only */
  317.           if( EItem->Mode != 'C' && EItem->Mode != 'S' )
  318.             ReportError("`CON' -- CLI or SCRIPT modes only");
  319.           if( !isstring(t=GetToken()) )
  320.             ReportError("Bad CON Argument");
  321.           if( EItem->Console )  FreeStr(M->Console);
  322.           EItem->Console = AllocStr(String);
  323.           break;
  324.         case DIR:        /* Current Directory -- not WB */
  325.           if( EItem->Mode == 'W' )
  326.             ReportError("`DIR' -- not in WB mode");
  327.           if( !isstring(t=GetToken()) )
  328.             ReportError("Bad DIR Argument");
  329.           if( EItem->Directory )  FreeStr(M->Directory);
  330.           EItem->Directory = AllocStr(String);
  331.           break;
  332.         default:
  333.           OptionLoop = FALSE;
  334.           break;
  335.         } /* switch */
  336.       } /* option loop */
  337.  
  338.         /* command */
  339.       if( !isstring(t) )
  340.         ReportError("Bad Command Given");
  341.       EItem->Cmd = AllocStr(String);
  342.  
  343.         /* read arguments */
  344.       t = NextChar;          /* char following command string*/
  345.       while( t != '\n' && t != EOF && isspace(t) )
  346.         t=GetC();            /* skip space */
  347.       p = String;
  348.       while( t != '\n' && t != EOF ) {
  349.         *p++ = t;            /* read in rest of line */
  350.         t = GetC(t);
  351.       }
  352.       *p++ = '\n';    /* make it a proper command line */
  353.       *p = '\0';
  354.       if( EItem->Mode != 'W' && EItem->Mode != 'S' ) /* ignore args? */
  355.         EItem->Args = AllocStr(String);
  356.       break; /* end of ITEM statement */
  357.  
  358.     default:
  359.       ReportError("Keyword Expected");
  360.     }
  361.  
  362.     DB( Printf("-END\n"); )
  363.   } /* While Token */
  364.  
  365.   switch( status ) {
  366.   case STAT_SUB:
  367.     EndSubMenu();
  368.   case STAT_MENU:
  369.     EndMenu();
  370.   }
  371.   LineNum = 0;        /* finished config file - no more syntax errors */
  372.   return FALSE;
  373. }
  374.  
  375.  
  376. BOOL
  377. ParseMenus()
  378.   /* Open and Read the Config File -- return FALSE if no error */
  379. {
  380.   BOOL Error;
  381.  
  382.   if( M->Directory )  FreeStr(M->Directory);
  383.   M->Directory = AllocStr(DEF_DIRECTORY);
  384.   if( M->Console )  FreeStr(M->Console);
  385.   M->Console = AllocStr(DEF_CONSOLE);
  386.  
  387.   StartMenu();
  388.   /*
  389.    * WB 1.3 had only 3 menus in the work bench
  390.   if( WBMenus != 3 )
  391.    */
  392.   if( WBMenus != 4 )
  393.     ReportError("Unusual Workbench Menus Found!");
  394.  
  395.   Config = ArpOpen(AMENU_CONFIG, MODE_OLDFILE);
  396.   if( !Config ) {
  397.     Config = ArpOpen(AMENU_CONFIG2, MODE_OLDFILE);  /* closed by Arp */
  398.     if( !Config )
  399.       ReportError("Can't find file");
  400.   }
  401.  
  402.   Error = ParseConfig();
  403.  
  404.   if( !Error && FinishMenu() ) {
  405.     SPrintf(String, "%s : \"%s\"", VERSION,
  406.               "Warning: Menu Overflows WorkBench Screen!");
  407.     Warn(String);       /* Warning - don't abort */
  408.   }
  409.  
  410.   return Error;
  411. }
  412.  
  413.